package com.changwu.cwbase.util;

import android.text.TextUtils;

import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
import java.util.Set;

/**
 * List和Array的工具函数类. 包含List和Array创建函数和转换函数
 * 
 * @author yinjinwen
 */
public final class ListUtil {
	// ~ Constructors
	// -----------------------------------------------------------

	/**
	 * Creates a new ListUtil object.
	 */
	private ListUtil() {
	}

	// ~ Methods
	// ----------------------------------------------------------------

	/**
	 * 【创建List】创建一个ArrayList
	 * 
	 * @param <E>
	 *            元素的类型
	 * 
	 * @return 创建的ArrayList
	 */
	public static <E> ArrayList<E> newList() {
		return new ArrayList<E>();
	}

	/**
	 * 【创建List】创建一个ArrayList
	 * 
	 * @param <E>
	 *            元素的类型
	 * @param list
	 *            TODO
	 * 
	 * @return 创建的ArrayList
	 */
	public static <E> ArrayList<E> newList(Collection<E> list) {
		if (list == null) {
			return new ArrayList<E>();
		} else {
			return new ArrayList<E>(list);
		}
	}

	/**
	 * 【创建List】根据任意个相同类型的参数创建一个ArrayList
	 * 
	 * @param <E>
	 *            元素的类型
	 * @param elements
	 *            TODO
	 * 
	 * @return 创建的ArrayList
	 */
	public static <E> ArrayList<E> newList(E... elements) {
		ArrayList<E> list = new ArrayList<E>();
		Collections.addAll(list, elements);

		return list;
	}

	/**
	 * 【创建数组】参数创建一个对象数组
	 * 
	 * @param <T>
	 *            元素的类型
	 * @param arr
	 *            TODO
	 * 
	 * @return 创建的数组
	 */
	public static <T> T[] newArray(T... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个boolean数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的boolean数组
	 */
	public static boolean[] newArray(boolean... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个byte数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的byte数组
	 */
	public static byte[] newArray(byte... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个char数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的char数组
	 */
	public static char[] newArray(char... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个short数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的short数组
	 */
	public static short[] newArray(short... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个int数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的int数组
	 */
	public static int[] newArray(int... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个long数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的long数组
	 */
	public static long[] newArray(long... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个float数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的float数组
	 */
	public static float[] newArray(float... arr) {
		return arr;
	}

	/**
	 * 【创建数组】创建一个double数组
	 * 
	 * @param arr
	 *            TODO
	 * 
	 * @return 包含所有参数的double数组
	 */
	public static double[] newArray(double... arr) {
		return arr;
	}

	/**
	 * 【数组转List】把一个对象数组转成List
	 * 
	 * @param <T>
	 *            元素的类型
	 * @param arr
	 *            数组
	 * 
	 * @return List集合
	 */
	// public static <T> List<T> toList(T[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<T> list = new ArrayList<T>();
	//
	// for (T t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个boolean数组转成List
	 * 
	 * @param arr
	 *            boolean数组
	 * 
	 * @return List集合
	 */
	// public static List<Boolean> toList(boolean[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Boolean> list = new ArrayList<Boolean>();
	//
	// for (boolean t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个char数组转成List
	 * 
	 * @param arr
	 *            char数组
	 * 
	 * @return List集合
	 */
	// public static List<Character> toList(char[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Character> list = new ArrayList<Character>();
	//
	// for (char t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个short数组转成List
	 * 
	 * @param arr
	 *            short数组
	 * 
	 * @return List集合
	 */
	// public static List<Short> toList(short[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Short> list = new ArrayList<Short>();
	//
	// for (short t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个int数组转成List
	 * 
	 * @param arr
	 *            int数组
	 * 
	 * @return List集合
	 */
	// public static List<Integer> toList(int[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Integer> list = new ArrayList<Integer>();
	//
	// for (int t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个long数组转成List
	 * 
	 * @param arr
	 *            long数组
	 * 
	 * @return List集合
	 */
	public static List<Long> toList(long[] arr) {
		List<Long> list = new ArrayList<Long>();
		if (arr == null) {
			return list;
		}

		for (long t : arr) {
			list.add(t);
		}

		return list;
	}

	/**
	 * 【数组转List】把一个String数组转成List
	 * 
	 * @param arr
	 *            String数组
	 * 
	 * @return List集合
	 */
	public static List<String> toList(String[] arr) {
		List<String> list = new ArrayList<String>();
		if (arr == null) {
			return list;
		}

		for (String t : arr) {
			list.add(t);
		}

		return list;
	}

	/**
	 * 【数组转List】把一个float数组转成List
	 * 
	 * @param arr
	 *            float数组
	 * 
	 * @return List集合
	 */
	// public static List<Float> toList(float[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Float> list = new ArrayList<Float>();
	//
	// for (float t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【数组转List】把一个double数组转成List
	 * 
	 * @param arr
	 *            double数组
	 * 
	 * @return List集合
	 */
	// public static List<Double> toList(double[] arr) {
	// if (arr == null) {
	// return null;
	// }
	//
	// List<Double> list = new ArrayList<Double>();
	//
	// for (double t : arr) {
	// list.add(t);
	// }
	//
	// return list;
	// }

	/**
	 * 【List转数组】把一个List转成对象数组
	 * 
	 * @param <T>
	 *            元素的类型
	 * @param list
	 *            List集合
	 * 
	 * @return 数组
	 */
	// @SuppressWarnings("unchecked")
	// public static <T> T[] toArray(List<T> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// T[] arr = (T[]) Array.newInstance(list.get(0).getClass(), list.size());
	//
	// return list.toArray(arr);
	// }

	/**
	 * 【List转数组】把一个List转成boolean数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return boolean数组
	 */
	// public static boolean[] toArray(List<Boolean> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// boolean[] arr = new boolean[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 【List转数组】把一个List转成char数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return char数组
	 */
	// public static char[] toArray(List<Character> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// char[] arr = new char[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 【List转数组】把一个List转成short数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return short数组
	 */
	// public static short[] toArray(List<Short> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// short[] arr = new short[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 【List转数组】把一个List转成int数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return int数组
	 */
	// public static int[] toArray(List<Integer> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// int[] arr = new int[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 【List转数组】把一个List转成long数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return long数组
	 */
	public static long[] toArray(List<Long> list) {
		if (list == null) {
			return null;
		}

		long[] arr = new long[list.size()];

		for (int i = 0; i < list.size(); i++) {
			arr[i] = list.get(i);
		}

		return arr;
	}

	/**
	 * 【List转数组】把一个List转成long数组
	 * 
	 *            List集合
	 * 
	 * @return long数组
	 */
	public static long[] toArray(Set<Long> set) {
		if (set == null) {
			return null;
		}

		Long[] arr = new Long[set.size()];

		int j = 0;
		for (Long list : set) {
			arr[j++] = list;
		}

		int idsLen = set.size();
		long[] idslong = new long[idsLen];
		for (int i = 0; i < idsLen; i++) {
			idslong[i] = arr[i];
		}

		return idslong;
	}

	/**
	 * 【List转数组】把一个List转成float数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return float数组
	 */
	// public static float[] toArray(List<Float> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// float[] arr = new float[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 【List转数组】把一个List转成double数组
	 * 
	 * @param list
	 *            List集合
	 * 
	 * @return double数组
	 */
	// public static double[] toArray(List<Double> list) {
	// if (list == null) {
	// return null;
	// }
	//
	// double[] arr = new double[list.size()];
	//
	// for (int i = 0; i < list.size(); i++) {
	// arr[i] = list.get(i);
	// }
	//
	// return arr;
	// }

	/**
	 * 判断一个List是否为空
	 * 
	 * @param <T>
	 *            元素的类型
	 * @param list
	 *            List集合
	 * @return 是否为空
	 */
	public static <T> boolean isEmpty(List<T> list) {
		if (list == null || list.size() == 0) {
			return true;
		} else {
			return false;
		}
	}

	/**
	 * 判断一个List是否不为空
	 * 
	 * @param <T>
	 *            元素的类型
	 * @param list
	 *            List集合
	 * @return 是否不为空
	 */
	public static <T> boolean isNotEmpty(List<T> list) {
		return !isEmpty(list);
	}

	public static String reduplicated(String date1, String date2) {
		if (TextUtils.isEmpty(date1) && TextUtils.isEmpty(date2)) {
			return "";
		}
		if (TextUtils.isEmpty(date1) && !TextUtils.isEmpty(date2)) {
			return date2;
		}
		if (!TextUtils.isEmpty(date1) && TextUtils.isEmpty(date2)) {
			return date1;
		}
		String result = date1 + date2;
		result = result.replaceAll("(?s)(.)(?=.*\\1)", "");
		char[] chs = result.toCharArray();
		List<String> list = new ArrayList<String>();
		for (int i = 0; i < chs.length; i++) {
			list.add(String.valueOf(chs[i]));
		}
		Collections.sort(list);
		StringBuffer buffer = new StringBuffer();
		for (String string : list) {
			buffer.append(string);
		}

		return buffer.toString();
	}

	/**
	 * list.toString()格式的字符串转成List
	 *
	 * @param listtoString
	 * @return
	 */
	public static List<String> listToStringToList(String listtoString) {
		List<String> list = new ArrayList<String>();
		List<String> arrList = new ArrayList<String>();
		listtoString = listtoString.replace("[", "");
		listtoString = listtoString.replace("]", "");
		if (listtoString.indexOf(",") > 0) {
			String array[] = listtoString.split(",");
			for (int i = 0; i < array.length; i++) {
				String s = array[i];
				s = s.replaceAll("\\s*", "");
				list.add(s);
			}
			arrList = new ArrayList<String>(list);

		} else {
			listtoString = listtoString.replaceAll("\\s*", "");
			arrList.add(listtoString);
		}
		return arrList;

	}

	public static List<String> listToStringToListRemoveCame(String listtoString) {
		List<String> list = new ArrayList<String>();
		List<String> arrList = new ArrayList<String>();
		listtoString = listtoString.replace("[", "");
		listtoString = listtoString.replace("]", "");
		if (listtoString.indexOf(",") > 0) {
			String array[] = listtoString.split(",");
			for (int i = 0; i < array.length; i++) {
				String s = array[i];
				if (list.contains(s)) {
					continue;
				} else {
					// s = s.replaceAll("\\s*", "");
					list.add(s);
				}
			}
			arrList = new ArrayList<String>(list);

		} else {
			// listtoString = listtoString.replaceAll("\\s*", "");
			arrList.add(listtoString);
		}
		return arrList;

	}

	class DataSortUitl implements Comparator<String> {

		@Override
		public int compare(String arg0, String arg1) {
			int flag = arg0.compareTo(arg1);
			return flag;
		}
	}

}